home *** CD-ROM | disk | FTP | other *** search
/ Packard Bell - Internet on a CD / internet on a cd.cdr / Internet / sites / Clementine_NASA / clemdsrc.hqx / clemdcmp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-07  |  17.6 KB  |  537 lines
  1. /*************************************************************************     
  2. *                   ----------------
  3. *                   |  CLEMDCMP    |
  4. *                   ----------------
  5. *
  6. *_TITLE CLEMDCMP Decompress clementine image into various formats
  7. * 
  8. *_DESC  CLEMDCMP will decompress a clementine image and format it into 
  9. *       one of four possible formats:
  10. *       1) decompressed pds image file, with pds labels, the historgram
  11. *           object, and an image object, either the browse image or
  12. *           the full image
  13. *       2) decompressed image file, no labels
  14. *       3) decompressed gif image
  15. *       4) decompressed tiff image
  16. *       This version is specifically for the Macintosh environment
  17. *
  18. *_HIST  Apr 07 1994  Tracie Sucharski, USGS, Flagstaff Original Version
  19. *       Aug 11 1994  Tracie Sucharski,  Added Apple menus and memory
  20. *                      handling
  21. *
  22. **************************************************************************/
  23.  
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27.  
  28. #include "pds.h"
  29.  
  30. #define MM_TYPE 0x4D4D
  31. #define II_TYPE 0x4949
  32.  
  33. #define version "24-Aug-94"      /* version date of program */
  34.  
  35. struct {
  36.     char prgnam[9];               /* Program name */
  37.     char hlpfil[13];              /* Help file name */
  38.     char infile[128];             /* Input file name */
  39.     char outfile[128];            /* Output file name */
  40.     char img;                     /* Output image or browse image */
  41.     char format;                  /* Output file format */
  42.     } clemargs;
  43.  
  44.   long int resnumq = 420;
  45.   long int resnum = 400;
  46.  
  47.  
  48. main()
  49. {
  50.   char errbuf[132];
  51.   long lines;                    /* Number of lines and sample of image */
  52.   long samps;
  53.   int  i;                       
  54.   FILE *fpi, *fpo;               /* Input and output file pointers */
  55.   int ret;                       /* Return code */
  56.   char b[2];
  57.   short int *j;
  58.   char bitord;
  59.   
  60.   CursHandle hcur;
  61.   
  62.   PDSINFO *p;
  63.  
  64.   int labmod(char *text, char img, char bitord);
  65.   int writetif(FILE *fp, long nl, long ns, CHARH *buf, char bitord);
  66.  
  67.   void macinit();
  68.   void errmsg();
  69.   void clemdcmp_menu(); 
  70.   
  71.  
  72. /*************************************************************************
  73. *  Initialize the toolbox
  74. *************************************************************************/
  75.   macinit();
  76.     
  77. /*************************************************************************
  78. *  Initialize input variables
  79. *************************************************************************/
  80.   strcpy(clemargs.prgnam,"Clemdcmp");
  81.   strcpy(clemargs.hlpfil,"clemdcmp.hlp");
  82.   strcpy(clemargs.outfile," ");
  83.   clemargs.img = 'i';
  84.   clemargs.format = 'n';
  85.     
  86. /*************************************************************************
  87. *  Get input parameters
  88. *************************************************************************/
  89.   clemdcmp_menu("NEW");
  90.   
  91. /************************************************************************
  92. *  Determine the bit order
  93. ************************************************************************/
  94.  
  95.   j = (short int *) b;
  96.   b[0] = 1;
  97.   b[1] = 0;
  98.   if (*j == 1) bitord = 'l';
  99.   else bitord = 'm';
  100.  
  101. /***************************************************************************
  102. *  The following call will open the compressed Clementine image and create
  103. *  a structure containing the file objects.
  104. ****************************************************************************/
  105.   hcur = GetCursor(4);
  106.   if (hcur) SetCursor(*hcur);
  107.   p = PDSR(clemargs.infile, &lines, &samps);
  108.   if (p==NULL) {
  109.     errmsg("ERROR:CLEMDCMP-Error in decompression toolkit",&resnumq);
  110.     clemdcmp_menu("OLD");
  111.     exit;
  112.   }
  113.  
  114. /****************************************************************************
  115. *  If user chooses to output the full image, make sure it exists.
  116. ****************************************************************************/
  117.   if (clemargs.img == 'i' && !(p->image)) {
  118.     errmsg("ERROR:CLEMDCMP-This file does not contain a full image", &resnumq);
  119.     clemdcmp_menu("OLD");
  120.     exit;
  121.   }
  122. /****************************************************************************
  123. *  If user chooses to output the browse image, make sure it exists.
  124. ****************************************************************************/
  125.   if (clemargs.img == 'b' && !(p->brw_imag)) {
  126.     errmsg("ERROR:CLEMDCMP-This file does not contain a browse image",&resnumq);
  127.     clemdcmp_menu("OLD");
  128.     exit;
  129.   }
  130.  
  131. /******************************************************************************
  132. *  Open output file
  133. ******************************************************************************/
  134.   fpo = fopen(clemargs.outfile, "wb");
  135.  
  136. /*****************************************************************************
  137. *  For the pds formatted option, the labels will need to be modified before 
  138. *  writing out.  The uncompressed output file will either be the image or 
  139. *  the browse image, so the pointer to the browse image will be deleted, 
  140. *  and the image pointer will be modified to point to the start of the data.  
  141. *  The pointer to the histogram will also need to be modified.  The 
  142. *  ENCODING_COMPRESSION_RATIO will no longer be applicable, so the value is 
  143. *  changed to "N/A". 
  144. ******************************************************************************/
  145.   if (clemargs.format == 'p') {
  146.     if (labmod(p->text, clemargs.img, bitord) < 0) {
  147.       errmsg("ERROR:CLEMDCMP-Error reformatting labels",&resnumq);
  148.       clemdcmp_menu("OLD");
  149.       exit;
  150.     }
  151.     fwrite(p->text, strlen(p->text), 1, fpo);
  152.   }
  153.  
  154.   if (clemargs.format == 'p' || clemargs.format == 'n') {
  155. /*****************************************************************************
  156. *  If writing a pds formatted file, write the histogram data followed by 
  157. *  the image data, either the browse image or the full image.  If writing
  158. *  an unlabeled raw image write out only the image data.
  159. *****************************************************************************/
  160.     if (p->hist == NULL && clemargs.format == 'p') {
  161.       errmsg("ERROR:CLEMDCMP-Histogram is empty",&resnumq);
  162.       clemdcmp_menu("OLD");
  163.       exit;
  164.     }
  165.     if (clemargs.format == 'p') fwrite(p->hist, sizeof(long), 256, fpo);
  166.     if (clemargs.img == 'i') {
  167.       HLock(p->image);
  168.       fwrite((CHARH *)*(p->image), lines*samps, 1, fpo);
  169.       HUnlock(p->image);
  170.       if (clemargs.format == 'n') {
  171.         InitCursor();
  172.           sprintf(errbuf, "The size of the raw image created is %ld lines by %ld samples \
  173.                  with no header or label data.",lines, samps);
  174.           errmsg(errbuf, &resnum);
  175.       }
  176.       
  177.     }    
  178.     
  179.     if (clemargs.img == 'b') {
  180.       HLock(p->brw_imag); 
  181.       fwrite((unsigned char *)*(p->brw_imag), p->browse_nrows*p->browse_ncols, 1, fpo);
  182.        HUnlock(p->brw_imag); 
  183.       if (clemargs.format == 'n') {
  184.         InitCursor();
  185.            sprintf(errbuf, "The size of the raw image created is %d lines by %d samples \
  186.                   with no header or label data.", p->browse_nrows, p->browse_ncols);
  187.           errmsg(errbuf, &resnum);
  188.       }
  189.  
  190.     }
  191.   }
  192.  
  193.  
  194.  
  195.   if (clemargs.img == 'b') {  /* Write browse image */
  196.     
  197.     if (clemargs.format == 't') { 
  198.      HLock(p->brw_imag); 
  199.     /*  if (writetif(fpo, p->browse_nrows, p->browse_ncols, p->brw_imag, bitord) < 0) {*/
  200.       if (writetif(fpo, p->browse_nrows, p->browse_ncols, (unsigned char *)*(p->brw_imag), bitord) < 0) {
  201.           errmsg("ERROR:CLEMDCMP-Error writing tiff format",&resnumq);
  202.           clemdcmp_menu("OLD");
  203.           exit;
  204.       }
  205.       HUnlock(p->brw_imag);
  206.     }
  207.  
  208.     if (clemargs.format == 'g') { 
  209.       if (writegif(fpo, (long)p->browse_nrows, (long)p->browse_ncols, p->brw_imag) < 0) {
  210.           errmsg("ERROR:CLEMDCMP-Error writing gif format",&resnumq);
  211.           clemdcmp_menu("OLD");
  212.           exit;
  213.       }
  214.     }
  215.    
  216.   }
  217.  
  218.   else  {  /* Write image */
  219.     
  220.     if (clemargs.format == 't')  {
  221.       HLock(p->image);
  222.       if (writetif(fpo, lines, samps, (CHARH *)*(p->image), bitord) < 0) {
  223.         errmsg("ERROR:CLEMDCMP-Error writing tiff format",&resnumq);
  224.         clemdcmp_menu("OLD");
  225.         exit;
  226.       }
  227.       HUnlock(p->image);
  228.     }
  229.  
  230.     if (clemargs.format == 'g') {
  231.       if (writegif(fpo, lines, samps, p->image) < 0) {
  232.         errmsg("ERROR:CLEMDCMP-Error writing gif format",&resnumq);
  233.         clemdcmp_menu("OLD");
  234.         exit;
  235.       }
  236.     }
  237.  
  238.   }    
  239.  
  240.  
  241.   fclose(fpo);
  242.   
  243.   InitCursor();
  244.   clemdcmp_menu("OLD");
  245.  
  246. }
  247.  
  248.  
  249.  
  250.  
  251.  
  252. int labmod(char *text, char img, char bitord)
  253. /*****************************************************************************
  254. *
  255. *_TITLE  LABMOD - modify the clementine label to reflect the decompression
  256. *
  257. *_ARGS    Type    Variable     I/O  Description
  258. *_PARM    char    *text;        I   Pointer to clementine label
  259. *_PARM    char    img           I   Image Type (Full image or browse image)
  260. *_PARM    char    bitord        I   Bit order of current machine
  261. *_PARM    int     *ret          O   Return code
  262. *                                   0 - OK
  263. *
  264. *_DESC  LABMOD will modify the clementine label to reflect the decompression,
  265. *       and the possible rearranging of the browse image and image object.
  266. *
  267. *_HIST  Apr 13 1994 Tracie Sucharski, USGS, Flagstaff Original Version
  268. *       Jun 27 1994 Tracie Sucharski,  Fixed bug when writing out the
  269. *                       browse image.
  270. *       Jul 14 1994 Tracie Sucharski,  Changed output value of ENCODING_
  271. *                       TYPE keyword.
  272. *       Aug 23 1994 Tracie Sucharski,  Added NOTE to image object if the
  273. *                       output image is the browse image, also correct
  274. *                       the DATA_TYPE keyword in the histogram object
  275. *                       to indicate the correct byte order.
  276. *
  277. ****************************************************************************/
  278. {
  279.     int lbllen;                     /* Length of incoming label */
  280.     int nlbllen;                    /* Length of outgoing label */
  281.     char *start, *end;              /* Index pointers */
  282.     char sdummy[80];
  283.     int nc;                         /* Number of characters */
  284.     char byte[4];                   /* Starting bytes of objects */
  285.     int hbyte;                      /* Starting byte of Image Historgram */
  286.     int ibyte;                      /* Starting byte of Image */
  287.     int bbyte;                      /* Starting byte of Browse Image */
  288.     int diff;                       /* Difference in bytes between input */
  289.                                     /* label and output label */
  290.     char labels[6000];              /* Temporary buffer to hold labels */
  291.  
  292.  
  293.     lbllen = strlen(text);
  294.  
  295.     start = strstr(text, "^IMAGE_HISTOGRAM ");
  296.     sscanf(start, "%s = %d", sdummy, &hbyte);
  297.  
  298.     start = strstr(text, "^IMAGE ");
  299.     sscanf(start, "%s = %d", sdummy, &ibyte);
  300.  
  301.     start = strstr(text, "^BROWSE_IMAGE ");
  302.     sscanf(start, "%s = %d", sdummy, &bbyte);
  303.  
  304. /****************************************************************************
  305. *  Get rid of pointer to browse image.
  306. ****************************************************************************/
  307.     end = strchr(start,'\n');
  308.     strcpy(start, end+1);
  309.  
  310. /***************************************************************************
  311. *  If browse image is being written, get rid of IMAGE object, rename
  312. *  BROWSE_IMAGE object to IMAGE and add a note to indicate the output
  313. *  image is the browse image.
  314. ***************************************************************************/
  315.     if (img == 'b') {
  316.       start = strstr(text, "OBJECT = IMAGE\n");
  317.       end = strstr(start, "END_OBJECT");
  318.       strcpy(start, end+11);
  319.  
  320.       start = strstr(text, " BROWSE_IMAGE");
  321.       end = strchr(start, '\n');
  322.       strncpy(labels, text, (start-text)+1);
  323.       *(labels+(start-text+1)) = '\0';
  324.       strcat(labels, "IMAGE");
  325.       strcat(labels, end);
  326.       strcpy(text, labels);
  327.  
  328.       end = strstr(start, "END_OBJECT");
  329.       strncpy(labels, text, (end-text)+1);
  330.       *(labels+(end-text)) = '\0';
  331.       strcat(labels, "  NOTE          = \"Averaged subsampled EDR image\"\n");
  332.       strcat(labels, end);
  333.       strcpy(text, labels);
  334.  
  335.     }
  336.  
  337. /***************************************************************************
  338. *  If writing IMAGE object change ENCODING_COMPRESSION_RATIO and
  339. *  ENCODING_TYPE keyvalues to "N/A", since the output file is uncompressed.
  340. ***************************************************************************/
  341.     if (img == 'i') {
  342.  
  343.       start = strstr(text, "ENCODING_TYPE ");
  344.       end = strchr(start, '\n');
  345.       strncpy(labels, text, (end-text)-1);
  346.       *(labels+(end-text-1)) = '\0';
  347.       strcat(labels, " DECOMPRESSED\"");
  348.       strcat(labels, end);
  349.       strcpy(text, labels);
  350.  
  351.       start = strstr(text, "ENCODING_COMPRESSION_RATIO ");
  352.       end = strchr(start, '\n');
  353.       strncpy(labels, text, (start-text)+29);
  354.       *(labels+(start-text+29)) = '\0';
  355.       strcat(labels, "\"N/A\"");
  356.       strcat(labels, end);
  357.       strcpy(text, labels);
  358.  
  359. /***************************************************************************
  360. *  Get rid of the BROWSE_IMAGE object.
  361. ***************************************************************************/
  362.       start = strstr(text, "OBJECT = BROWSE_IMAGE");
  363.       end = strstr(start, "END_OBJECT");
  364.       strcpy(start, end+11);
  365.     }
  366.     
  367. /****************************************************************************
  368. *  If the bitorder is MSB which is different from that in the label(LSB),
  369. *  change the label.
  370. ****************************************************************************/
  371.     if (bitord == 'm') {
  372.       start = strstr(text, "LSB_INTEGER");
  373.       *start = 'M';
  374.     }
  375.  
  376. /****************************************************************************
  377. *  Adjust the object pointers.
  378. ****************************************************************************/
  379.     nlbllen = strlen(text);
  380.     hbyte = nlbllen + 1;
  381.     ibyte = hbyte + 1024;
  382.  
  383. /*****************************************************************************
  384. *  Now that there are new pointer values, write them out to the labels.
  385. *****************************************************************************/
  386.     sprintf(byte, "%d", hbyte);
  387.     nc = strlen(byte);
  388.     start = strstr(text, "^IMAGE_HISTOGRAM ");
  389.     strncpy(start+19, byte, nc);
  390.  
  391.     sprintf(byte, "%d", ibyte);
  392.     nc = strlen(byte);
  393.     start = strstr(text, "^IMAGE ");
  394.     strncpy(start+19, byte, nc);
  395.  
  396.     return(0);
  397.  
  398. }
  399.  
  400.     
  401.  
  402. /*************************************************************************
  403. *                       ------------
  404. *                       | WRITETIF |
  405. *                       ------------
  406. *
  407. *_TITLE  WRITETIF  Writes decompressed Clementine data into TIF format
  408. *
  409. *_DESC   WRITETIF takes decompressed Clementine data and writes an 
  410. *        uncompressed TIF formatted image.
  411. *
  412. *_HIST   May 04 1994  Tracie Sucharski, USGS, Flagstaff Original Version
  413. *
  414. *************************************************************************/
  415. #define BLKSIZE 32768L
  416.  
  417. int writetif(FILE *fp, long nl, long ns, CHARH *buf, char bitord)
  418. {
  419.   unsigned int j, nblocks, rem; /* Added by Luis Perez 06/29/94 */
  420.  
  421.   int fputword(FILE *fp, short int n);
  422.   int fputlong(FILE *fp, long n);
  423.  
  424.  
  425. /********************************************************************
  426. *  Write out the TIF header
  427. ********************************************************************/
  428.   if (bitord == 'm')  fputword(fp, MM_TYPE);
  429.   if (bitord == 'l')  fputword(fp, II_TYPE);
  430.   fputword(fp,42);
  431.   fputlong(fp,8L);
  432.  
  433. /********************************************************************
  434. *  Construct the Image File Directory (IFD)
  435. ********************************************************************/
  436.   fputword(fp, 8);     /* Eight Tags */
  437.  
  438.   fputword(fp, 254);   /* NewSubfileType */
  439.   fputword(fp, 4);     /* Long */
  440.   fputlong(fp, 1L);
  441.   fputlong(fp, 0L);
  442.  
  443.   fputword(fp, 256);   /* ImageWidth */
  444.   fputword(fp, 3);     /* Short */
  445.   fputlong(fp, 1L);    
  446.   if (bitord == 'm')
  447.     fputlong(fp, ns*65536); /* Shift value into the two high order bytes */
  448.   if (bitord == 'l')
  449.     fputlong(fp, ns);
  450.  
  451.   fputword(fp, 257);   /* ImageLength */
  452.   fputword(fp, 3);     /* Short */
  453.   fputlong(fp, 1L);
  454.   if (bitord == 'm')
  455.     fputlong(fp, nl*65536);  /* Shift value into the two high order bytes */
  456.   if (bitord == 'l')
  457.     fputlong(fp, nl);
  458.  
  459.   fputword(fp, 258);   /* BitsPerSample */
  460.   fputword(fp, 3);     /* Short */
  461.   fputlong(fp, 1L);
  462.   if (bitord == 'm') 
  463.     fputlong(fp, 524288L); /* 8 Shifted into the two high order bytes */
  464.   if (bitord == 'l')
  465.     fputlong(fp, 8L);
  466.  
  467.   fputword(fp, 259);   /* Compression */
  468.   fputword(fp, 3);     /* Short */
  469.   fputlong(fp, 1L);
  470.   if (bitord == 'm')
  471.     fputlong(fp, 65536L);    /* No compression */
  472.   if (bitord == 'l')
  473.     fputlong(fp, 1L);
  474.  
  475.   fputword(fp, 262);   /* PhotometricInterpretation */
  476.   fputword(fp, 3);     /* Short */
  477.   fputlong(fp, 1L);
  478.   if (bitord == 'm')
  479.     fputlong(fp, 65536L);  /* 1 Shifted into the two high order bytes */
  480.   if (bitord == 'l')
  481.     fputlong(fp, 1L);
  482.  
  483.   fputword(fp, 273);   /* StripOffsets - Start of image data */
  484.   fputword(fp, 4);     /* Long */
  485.   fputlong(fp, 1L);
  486.   fputlong(fp, 110L);
  487.  
  488.   fputword(fp, 277);   /* SamplesPerPixel */
  489.   fputword(fp, 3);     /* Short */
  490.   fputlong(fp, 1L);
  491.   if (bitord == 'm')
  492.     fputlong(fp, 65536L);
  493.   if (bitord == 'l')
  494.     fputlong(fp, 1L);
  495.  
  496.   fputlong(fp, 0L);
  497.  
  498. /***********************************************************************
  499. *  Write image data
  500. ***********************************************************************/
  501.   /*!!!!!! BE CAREFUL HERE !!!!!!*/
  502.   /* The third argument in fwrite is of type size_t, which under Turbo C
  503.      becomes an unsigned short int (16 bit integer). This means you have
  504.      to write the image data out in blocks of 64K bytes or less (32K is a
  505.      good number).
  506.      Added by Luis Perez 06/29/94. */
  507. #ifdef __TURBOC__
  508.   nblocks = (nl*ns) / BLKSIZE;
  509.   rem = (nl*ns) % BLKSIZE;
  510.   for (j=0; j<nblocks; j++, buf+=BLKSIZE)
  511.     fwrite(buf,1,BLKSIZE,fp);
  512.   if ( rem > 0 )
  513.     fwrite(buf,1,rem,fp);
  514. #else
  515.   fwrite(buf, 1, nl*ns, fp);
  516. #endif
  517.  
  518.   return(0);
  519.  
  520. }
  521.  
  522.  
  523.  
  524.  
  525. int fputword(FILE *fp, short int n)
  526. {
  527.   fwrite(&n, 2, 1,fp);
  528.   
  529. }
  530.  
  531. int fputlong(FILE *fp, long n)
  532. {
  533.   fwrite(&n, 4, 1, fp);
  534.  
  535. }
  536.  
  537.